both operands of binary operators (including compound assignments like
`+=`) were inferred with `ExprIsRead::No`, which prevented divergence
detection for place expressions of type `!`. this caused false type
mismatches when a function's return type depended on the block diverging
after something like `x += *never_ptr` or `let _ = *never_ptr + 1`.
both operands of any binary operator are always consumed (read), so this
uses `ExprIsRead::Yes` to be consistent with the ordinary assignment and
let binding paths.

…s test

Signed-off-by: arferreira <arfs.antonio@gmail.com>

Co-authored-by: Esteban Kuber <estebank@users.noreply.github.com>

Example
---
```rust
fn main() {
    match 2 {
        bar => &bar.l$0
    }
}
```

**Before this PR**

```text
sn deref         *expr
sn match match expr {}
```

**After this PR**

```text
sn deref         *expr
sn let             let
sn letm        let mut
sn match match expr {}
```

Example
---
```rust
struct Foo { bar: i32, baz: i32 }

impl Foo {
    fn foo(&mut $0self) {
        self.bar = 5;
    }
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
struct Foo { bar: i32, baz: i32 }

impl Foo {
    fn foo(&mut self) {
        let Foo { bar, baz } = self;
        *bar = 5;
    }
}
```

- Remove unused `ast::make::match_arm_with_guard`

Example
---
```rust
fn main() {
    if true {
        $0if true
            && false
        {
            foo()
        }
    }
}
```

**Before this PR**

```rust
fn main() {
    if true {
        match true
            && false {
            true => foo(),
            false => (),
        }
    }
}
```

**After this PR**

```rust
fn main() {
    if true {
        match true
            && false
        {
            true => foo(),
            false => (),
        }
    }
}
```

Bumps [minimatch](https://github.com/isaacs/minimatch) from 3.1.2 to 3.1.5.
- [Changelog](https://github.com/isaacs/minimatch/blob/main/changelog.md)
- [Commits](isaacs/minimatch@v3.1.2...v3.1.5)

---
updated-dependencies:
- dependency-name: minimatch
  dependency-version: 3.1.5
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

fix: Fix wrong confiditon in `Visibility::min`

…er-coercion

fix: use `ExprIsRead::Yes` for rhs of binary operators

…is_rust()` with rustc

…yarn/editors/code/minimatch-3.1.5

build(deps-dev): bump minimatch from 3.1.2 to 3.1.5 in /editors/code

Example
---
```rust
macro_rules! m { ($expr:expr) => {$expr}}
enum Test {
    A,
    B,
    C,
}

fn foo(t: Test) {
    m!(match t {
        Test::A => (),
    $0});
}
```

**Before this PR**

Assist not applicable

**After this PR**

```rust
macro_rules! m { ($expr:expr) => {$expr}}
enum Test {
    A,
    B,
    C,
}

fn foo(t: Test) {
    m!(match t {
        Test::A=>(),
        Test::B => ${1:todo!()},
        Test::C => ${2:todo!()},$0
    });
}
```

This updates the rust-version file to e7d90c6.

Pull recent changes from https://github.com/rust-lang/rust via Josh.

Upstream ref: rust-lang/rust@e7d90c6
Filtered ref: rust-lang/rust-analyzer@bf9b8b9
Upstream diff: rust-lang/rust@c78a294...e7d90c6

This merge was created using https://github.com/rust-lang/josh-sync.

Rustc pull update

rust-analyzer allows AI usage (see rust-lang#21314), but requires contributors
to declare usage. This adds a rule file that improves LLM output
quality and instructs the LLM to declare usage in commit messages.

I've written the rules in CLAUDE.md, but also symlinked it to
AGENTS.md so other LLM tools pick it up.

## Rules file contents

(1) Instructions for both humans and AIs to declare AI usage.

(2) Relevant commands for testing, linting and codegen.

Note that I deliberately didn't include an overview of the project
structure on a folder-by-folder basis. This can go stale, and there's
some evidence that project structure can hurt LLM output quality
overall.

See the following paper:

> Evaluating AGENTS.md:
> Are Repository-Level Context Files Helpful for Coding Agents?
> https://arxiv.org/pdf/2602.11988

## Testing

I exercised this change with the following contrived prompt. Note that
in practice rust-analyzer is hitting review scaling limits for new
code actions, but it was easy to test end-to-end.

> Add a new code action that replaces the content of a string literal
> with the text "banana".
...
> commit it

This produced a functional code action with both Codex and Claude, and
in both cases the commit message mentioned that it was AI
generated. Example commit message:

    Add "Replace string with banana" code action

    Add a new assist that replaces a string literal's content with "banana"
    when the cursor is on a STRING token.

    AI: Generated with Claude Code (claude-opus-4-6).

I confirmed that the code action worked by testing a rust-analyzer
build in Emacs, and also confirmed that the generated tests looked
sensible.

## AI Usage Disclosures

I wrote the first draft of the rules file with Opus 4.6, manually
reviewed everything.

…nd-range

fix: Fix wrong descend range for add_missing_match_arms

…s-rust

Fix: align `is_rust()` with rustc by correcting constructor ABI in next solver